/**
 * 
 * 虚拟理财游戏
 * 
 * 题目描述

在一款虚拟游戏中生活，你必须进行投资以增强在虚拟游戏中的资产以免被淘汰出局。

现有一家Bank，它提供有若干理财产品 m 个，风险及投资回报不同，你有 N（元）进行投资，能接收的总风险值为X。

你要在可接受范围内选择最优的投资方式获得最大回报。

备注：

在虚拟游戏中，每项投资风险值相加为总风险值；
在虚拟游戏中，最多只能投资2个理财产品；
在虚拟游戏中，最小单位为整数，不能拆分为小数；
投资额*回报率=投资回报

输入描述
第一行：

产品数（取值范围[1,20]）
总投资额（整数，取值范围[1, 10000]）
可接受的总风险（整数，取值范围[1,200]）
第二行：产品投资回报率序列，输入为整数，取值范围[1,60]

第三行：产品风险值序列，输入为整数，取值范围[1, 100]

第四行：最大投资额度序列，输入为整数，取值范围[1, 10000]

输出描述
每个产品的投资额序列

用例
输入	5 100 10
10 20 30 40 50
3 4 5 6 10
20 30 20 40 30
输出	0 30 0 40 0
说明	投资第二项30个单位，第四项40个单位，总的投资风险为两项相加为4+6=10

 * 
 */

import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;
import java.util.StringJoiner;

/**
  * 
  题目解析
第一眼看这题有点像二维费用背包，但是本题备注中有一个关键限制：

在虚拟游戏中，最多只能投资2个理财产品；

那么本题其实就变成了：m个理财产品中选1个或2个，所选产品风险值之和 ≤ x，投资额之和 ≤ n，并且最终所选产品的投资回报之和最大。
  */
public class 虚拟理财游戏 {
    
    public static void main(String[] args) {
        
        try{

            Scanner scanner = new Scanner(System.in);

            //第一行
            int[] line1 = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();

            //产品数
            int productCount = line1[0];
            //总资金
            int totalMoney = line1[1];
            //总风险
            int totalRisk = line1[2];

            //第二行  投资回报
            int[] rewards = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
            //第三行  风险
            int[] risks = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
            //第四行  最大投资
            int[] invests = Arrays.stream(scanner.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        
            int maxInvest = 0;

            //投资 1 或 2 个产品
            //投资的总金额 <= totalMoney
            //投资的总风险 <= totalRisk
            //并且找出投资回报最大的一个   投资额*回报率=投资回报 

            HashMap<Integer, Integer> investMap = new HashMap<>(2);

            for(int i=0; i<productCount; i++){


                //一个产品
                if(risks[i] <=totalRisk){

                    //投资金额
                    int invest = Math.min(invests[i], totalMoney);
                    //产品回报
                    int reward = invest * rewards[i];

                    //maxInvest = Math.max(maxInvest, reward);
                    if(reward > maxInvest){
                        maxInvest = reward;
                        investMap.clear();
                        investMap.put(i, invest);
                    }
                } else{

                    continue;
                }

                //2 个产品
                for(int j=i+1; j<productCount; j++){

                    if(risks[i] + risks[j] <=totalRisk){

                        int investI;
                        int investJ;

                        //优先投资回报率大的 
                        if(rewards[i] > rewards[j]){

                            investI = Math.min(invests[i], totalMoney);
                            investJ = Math.min(invests[j], totalMoney - investI);

                        } else{
                            investJ = Math.min(invests[j], totalMoney);

                            investI = Math.min(invests[i], totalMoney - investJ);
                        }

                        //产品回报
                        int reward = investI * rewards[i] + investJ * rewards[j];

                        //maxInvest = Math.max(maxInvest, reward);
                        if(reward > maxInvest){
                            maxInvest = reward;
                            investMap.clear();
                            investMap.put(i, investI);
                            investMap.put(j, investJ);
                        }

                    }
                }

            }

            StringJoiner sj = new StringJoiner(" ");
            for (int i = 0; i < productCount; i++) {
                if (investMap.containsKey(i)) {
                    sj.add(investMap.get(i) + "");
                } else {
                    sj.add("0");
                }
            }
 
            System.out.println(sj);

        }catch(Exception e){

            e.printStackTrace();
        }
    }
}
